home *** CD-ROM | disk | FTP | other *** search
/ AOL File Library: 2,801 to 2,900 / aol-file-protocol-4400-2801-to-2900.zip / AOLDLs / C++ Files Library / SK (Sockects) 1.4.1 r2 / SK v1.4.1 r2.sit / SK 1.4.1 r2 / SK / SK Sources / SK_INET.cc < prev    next >
Text File  |  1994-06-13  |  22KB  |  972 lines
  1. /***************************************************************************
  2. * 
  3. * 
  4. * Copyright ⌐ 1992-1994 Matthias Neeracher and the Decision Systems Group
  5. * 
  6. * Permission is granted to anyone to use this software for any purpose on
  7. * any computer system, and to redistribute it freely, subject to the
  8. * following restrictions:
  9. * 
  10. * 1) The authors and the Decision Systems Group are not responsible for 
  11. *    the direct or indirect consequences of use of this software, no matter 
  12. *    how awful, even if they arise from defects in the software itself.
  13. *    This restriction applies to the use of this and any derived source code 
  14. *    and also to the use of all binary produced from this and any derived 
  15. *    source code.
  16. * 2) The origin and copyrights of this software must not be misrepresented, 
  17. *    either by explicit claim or by omission or alteration of copyright or
  18. *    authorship header information in this file or in any derived file.
  19. * 3) Altered or derived versions must be plainly marked as such, and must not
  20. *    be misrepresented as being the original software.
  21. * 
  22. * We encourage users of this software to provide feedback, bug fixes,
  23. * and enhancements to the authors for incorporation into future releases.
  24. *
  25. * ==========================================================================
  26. * 
  27. * FILE: SK_INET.cc
  28. * 
  29. * AUTHOR: Matthias Neeracher and Stephan Deibel
  30. * 
  31. * CREATION DATE: 12Aug92
  32. * 
  33. * VERSION: 13Jun94
  34. * 
  35. * DESCRIPTION: 
  36. *
  37. * General routines for TCP and UDP sockets
  38. * 
  39. * NOTES: 
  40. * 
  41. * 0) This code was derived from Matthias Neerarcher's GUSI 1.1.0 and
  42. *    the socket library written by Charlie Reiman (creiman@ncsa.uiuc.edu)
  43. *    and Tom Milligan (milligan@madhaus.utcs.utoronto.ca); Copyrights
  44. *    are subject to this origin.
  45. *
  46. * MODIFICATIONS: 
  47. * --------------------------------------------------------------------------
  48. * Date     Name      Description of modification
  49. * --------------------------------------------------------------------------
  50. * 
  51. * 16Aug92    MN       Split
  52. * 20Aug92    MN       Wrote most of the functions
  53. * 23Aug92    MN       CSK_INETSocket::Available()
  54. * 31Jan93    MN       Inetd support
  55. * 07Feb93    MN       New configuration technique
  56. * 13Jul93    SD       Port to THINK C++ 6.0
  57. * 21Jul93    SD       Subsetted to only TCP/UDP, applied DSG naming 
  58. *                    conventions and commenting guidelines, and
  59. *                    changed name to "SK" for clear distinction from
  60. *                    the GUSI code from which this was derived
  61. * 13Jun94   SD       Updated based on relevant changes to GUSI (through 1.4.1)
  62. * 
  63. */
  64.  
  65. #include "SK_INET_P.hh"
  66. #include <machine/endian.h>
  67. #include <AppleEvents.h>
  68.  
  69.  
  70. /**************************************************************************/ 
  71. /**************************************************************************/ 
  72. /* Constants */
  73.  
  74. #define SKk_Num_PBs    32
  75.  
  76.  
  77. /**************************************************************************/ 
  78. /**************************************************************************/ 
  79. /* Globals */
  80.  
  81. CSK_INETSocketDomain SKg_INETSockets;
  82.  
  83.  
  84. /**************************************************************************/ 
  85. /**************************************************************************/ 
  86. /* Utilities */
  87.  
  88.  
  89. /*************************************************************************** *
  90. * Miscellaneous type conversion functions */
  91.  
  92. unsigned long (htonl)(unsigned long h)
  93. {
  94.     return h;
  95. }
  96.  
  97. unsigned short    (htons)(unsigned short h)
  98. {
  99.     return h;
  100. }
  101.  
  102. unsigned long (ntohl)(unsigned long n)
  103. {
  104.     return n;
  105. }
  106.  
  107. unsigned short    (ntohs)(unsigned short n)
  108. {
  109.     return n;
  110. }
  111.  
  112.  
  113. /*************************************************************************** *
  114. * FUNCTION:
  115. *
  116. * SK_TCPError
  117. *
  118. * DESCRIPTION:
  119. *
  120. * Our resident MacTCP error expert.  Convert MacTCP err codes into Unix 
  121. * error codes.
  122. *
  123. * PARAMETERS:
  124. *
  125. * int            -- Mac TCP error code
  126. *
  127. * RETURNS:
  128. *
  129. * int            -- Unix error code
  130. *
  131. */
  132.  
  133. int SK_TCPError(int MacTCPerr)
  134. {
  135.     switch ( MacTCPerr ) {
  136.     case 0:
  137.         return 0;
  138.     case ipBadLapErr:
  139.     case ipBadCnfgErr:
  140.     case ipNoCnfgErr:
  141.     case ipLoadErr:
  142.     case ipBadAddr:
  143.         errno = ENXIO;            /* device not configured */    /* a cheap cop out */
  144.         break;
  145.     case connectionClosing:
  146.         errno = ESHUTDOWN;        /* Can't send after socket shutdown */
  147.         break;
  148.     case connectionExists:
  149.         errno = EISCONN;        /* Socket is already connected */
  150.         break;
  151.     case connectionTerminated:
  152.         errno = ENOTCONN;        /* Connection reset by peer */  /* one of many possible */
  153.         break;
  154.     case openFailed:
  155.         errno = ECONNREFUSED;    /* Connection refused */
  156.         break;
  157.     case duplicateSocket:        /* technically, duplicate port */
  158.         errno = EADDRINUSE;        /* Address already in use */
  159.         break;
  160.     case ipDestDeadErr:
  161.         errno = EHOSTDOWN;        /* Host is down */
  162.         break;
  163.     case ipRouteErr:
  164.         errno = EHOSTUNREACH;    /* No route to host */
  165.         break;
  166.     default:
  167.         errno = MacTCPerr > 0 ? MacTCPerr : EFAULT;        /* cop out; an internal err, unix err, or no err */
  168.         break;
  169.     }
  170.  
  171.     return -1;
  172. }
  173.  
  174.  
  175. /*************************************************************************** *
  176. * FUNCTION:
  177. *
  178. * SK_TCPPossession
  179. *
  180. * DESCRIPTION:
  181. *
  182. * INETD support / for TCP
  183. *
  184. * PARAMETERS:
  185. *
  186. * AppleEvent *        -- incoming message
  187. * AppleEvent *        -- unused reply
  188. * long                -- unused refin
  189. *
  190. * RETURNS:
  191. *
  192. * OSErr                -- Error return (0 = no error)
  193. *
  194. * NOTES:
  195. *
  196. * This is a pascal callable function because it is installed as a callback
  197. * used with the Macintosh toolbox Apple Event Manager.
  198. *
  199. */
  200.  
  201. pascal OSErr 
  202. SK_TCPPossession(AppleEvent* messagein, AppleEvent*, long)
  203. {
  204.     AEDesc streamDesc;
  205.     OSErr theErr;
  206.     CSK_TCPSocket *sock;
  207.  
  208.     if ((theErr = AEGetParamDesc(messagein, 'STRM', typeLongInteger, &streamDesc)) == noErr) {
  209.         HLock(streamDesc.dataHandle);
  210.         sock = new CSK_TCPSocket(*((StreamPtr*) *(streamDesc.dataHandle)));
  211.         HUnlock(streamDesc.dataHandle);
  212.         SKg_SocketTable.Possess(0, sock);
  213.         SKg_SocketTable.Possess(1, sock);
  214.         SKg_SocketTable.Possess(2, sock);
  215.         
  216.         theErr = AEDisposeDesc(&streamDesc);
  217.     }
  218.  
  219.     return theErr;
  220. }
  221.  
  222.  
  223. /*************************************************************************** *
  224. * FUNCTION:
  225. *
  226. * SK_TCPPossession
  227. *
  228. * DESCRIPTION:
  229. *
  230. * INETD support / for UDP
  231. *
  232. * PARAMETERS:
  233. *
  234. * AppleEvent *        -- incoming message
  235. * AppleEvent *        -- unused reply
  236. * long                -- unused ref_in
  237. *
  238. * RETURNS:
  239. *
  240. * OSErr                -- Error return (0 = no error)
  241. *
  242. * NOTES:
  243. *
  244. * This is a pascal callable function because it is installed as a callback
  245. * used with the Macintosh toolbox Apple Event Manager.
  246. *
  247. */
  248.  
  249. pascal OSErr 
  250. SK_UDPPossession(AppleEvent* messagein, AppleEvent*, long)
  251. {
  252.     AEDesc streamDesc;
  253.     OSErr theErr;
  254.     CSK_UDPSocket *sock;
  255.  
  256.     if ((theErr = AEGetParamDesc(messagein, 'STRM', typeLongInteger, &streamDesc)) == noErr) {
  257.         HLock(streamDesc.dataHandle);
  258.         sock = new CSK_UDPSocket(*((StreamPtr*) *(streamDesc.dataHandle)));
  259.         HUnlock(streamDesc.dataHandle);
  260.         SKg_SocketTable.Possess(0, sock);
  261.         SKg_SocketTable.Possess(1, sock);
  262.         SKg_SocketTable.Possess(2, sock);
  263.         
  264.         theErr = AEDisposeDesc(&streamDesc);
  265.     }
  266.  
  267.     return theErr;
  268. }
  269.  
  270.  
  271. /**************************************************************************/ 
  272. /**************************************************************************/ 
  273. /* CSK_INETSocket members */
  274.  
  275.  
  276. /*************************************************************************** *
  277. * FUNCTION:
  278. *
  279. * CSK_INETSocket::CSK_INETSocket
  280. *
  281. * DESCRIPTION:
  282. *
  283. * Constructor for this class
  284. *
  285. */
  286.  
  287. CSK_INETSocket::CSK_INETSocket()
  288.     : CSK_Socket()
  289. {
  290.     bzero(&fMySocketAddress, sizeof(struct sockaddr_in));
  291.     bzero(&fPeerSocketAddress, sizeof(struct sockaddr_in));
  292.     
  293.     fMySocketAddress.sin_family    = AF_INET;
  294.     fMySocketAddress.sin_len = sizeof(struct sockaddr_in);
  295.     fStatus    = SKk_STATUS_USED;
  296.     fNonBlocking = false;    
  297.      
  298.     SKg_INETSockets.OpenSocket();
  299. }
  300.  
  301.  
  302. /*************************************************************************** *
  303. * FUNCTION:
  304. *
  305. * CSK_INETSocket::CSK_INETSocket
  306. *
  307. * DESCRIPTION:
  308. *
  309. * Constructor for this class
  310. *
  311. * PARAMETERS:
  312. *
  313. * StreamPtr            -- Stream to use for this internet socket
  314. *
  315. */
  316.  
  317. CSK_INETSocket::CSK_INETSocket(StreamPtr stream)
  318.     : CSK_Socket(), fStream(stream)
  319. {
  320.     fMySocketAddress.sin_family    = AF_INET;
  321.     fMySocketAddress.sin_len = sizeof(struct sockaddr_in);
  322.     fPeerSocketAddress.sin_family= AF_INET;
  323.     fPeerSocketAddress.sin_len = sizeof(struct sockaddr_in);
  324.     fStatus = SKk_STATUS_USED;
  325.     fSocketState = SKk_STATE_CONNECTED;
  326.     fNonBlocking = false;    
  327.      
  328.     SKg_INETSockets.OpenSocket();
  329. }
  330.  
  331.  
  332. /*************************************************************************** *
  333. * FUNCTION:
  334. *
  335. * CSK_INETSocket::~CSK_INETSocket
  336. *
  337. * DESCRIPTION:
  338. *
  339. * Destructor for this class
  340. *
  341. */
  342.  
  343. CSK_INETSocket::~CSK_INETSocket()
  344. {
  345.     SKg_INETSockets.CloseSocket();
  346. }
  347.  
  348.  
  349. /*************************************************************************** *
  350. * FUNCTION:
  351. *
  352. * CSK_INETSocket::Available
  353. *
  354. * DESCRIPTION:
  355. *
  356. * Compute the number of bytes available for reading on this socket.
  357. *
  358. * RETURNS:
  359. *
  360. * Number of bytes available, or 0 if none.
  361. *
  362. * NOTES:
  363. *
  364. * This member function must be overridden and implemented by descendents.
  365. *
  366. */
  367.  
  368. unsigned long CSK_INETSocket::Available()
  369. {
  370.     return 0;
  371. }
  372.  
  373.  
  374. /*************************************************************************** *
  375. * FUNCTION:
  376. *
  377. * CSK_INETSocket::bind
  378. *
  379. * DESCRIPTION:
  380. *
  381. * Requests that the name (ip address and port) pointed to by 
  382. * name be assigned to this socket.
  383. *
  384. * PARAMETERS:
  385. *
  386. * void *        -- The ip address to bind to
  387. * int            -- The length of the given ip address
  388. *
  389. * RETURNS:
  390. *
  391. * The return value is 0 on success or -1 if an error occurs,
  392. * in which case global variable errno is set to one of:
  393. *
  394. * EAFNOSUPPORT        The address family in name is not AF_INET.
  395. *        
  396. * EINVAL              The socket is already bound to an address.
  397. *        
  398. * EADDRNOTAVAIL       The specified address is  not  available
  399. *                       from the local machine. ie. the address
  400. *                      portion of name was not this machine's address.
  401. *
  402. * NOTES:
  403. *
  404. * MacTCP does not separate name binding and connection establishment.
  405. * Therefore the port number is not verified, just stored for later use.
  406. *
  407. * If a specific local port is not required, bind is optional in this
  408. * implementation.
  409. *
  410. */
  411.  
  412. int CSK_INETSocket::bind(void * addr, int namelen)
  413. {
  414.     struct sockaddr_in *name = (struct sockaddr_in *) addr;
  415.         
  416.     if (namelen < sizeof(struct sockaddr_in))
  417.         return SK_Error(EINVAL);
  418.  
  419.     if (name->sin_family != AF_INET)
  420.         return SK_Error(EAFNOSUPPORT);
  421.  
  422.     /* already bound */
  423.     if (fMySocketAddress.sin_port != 0)
  424.         return SK_Error(EINVAL);
  425.  
  426.     /* If client passed a local IP address, assure it is the right one */
  427.     if (name->sin_addr.s_addr != 0) 
  428.     {
  429.         struct GetAddrParamBlock pbr;
  430.         
  431.         pbr.ioCRefNum = SKg_INETSockets.Driver();
  432.         pbr.csCode = ipctlGetAddr;
  433.         
  434.         if (PBControlSync(ParmBlkPtr(&pbr)))
  435.             return SK_Error(ENETDOWN);
  436.         
  437.         if (name->sin_addr.s_addr != pbr.ourAddress)
  438.             return SK_Error(EADDRNOTAVAIL);
  439.     }
  440.  
  441.     /* NOTE: can't check a TCP port for EADDRINUSE just save the address 
  442.        and port away for connect or listen or... */
  443.     fMySocketAddress.sin_addr.s_addr = name->sin_addr.s_addr;
  444.     fMySocketAddress.sin_port = name->sin_port;
  445.     
  446.     return 0;
  447. }
  448.  
  449.  
  450. /*************************************************************************** *
  451. * FUNCTION:
  452. *
  453. * CSK_INETSocket::getsockname
  454. *
  455. * DESCRIPTION:
  456. *
  457. * Get the current name for this socket.
  458. *
  459. * PARAMETERS:
  460. *
  461. * void *            -- Pointer to memory for return value
  462. * int *                -- Pointer to memory for return value.  Should be initialized
  463. *                       the amount of space provided for name return
  464. *
  465. * RETURNS:
  466. *
  467. * The function return value indicates error status (0 = no error).  When it is
  468. * -1, a more specific return value is in the global errno.
  469. *
  470. * The name is returned in the given memory, truncated to available space
  471. * if necessary.  The length of the name (or truncated name) is returned
  472. * in the given int * parameter.
  473. *
  474. */
  475.  
  476. int CSK_INETSocket::getsockname(void *name, int *namelen)
  477. {
  478.     if (*namelen < 0)
  479.         return SK_Error(EINVAL);
  480.  
  481.     memcpy(name, &fMySocketAddress, *namelen = MIN(*namelen, sizeof(struct sockaddr_in)));
  482.     return 0;
  483. }
  484.  
  485.  
  486. /*************************************************************************** *
  487. * FUNCTION:
  488. *
  489. * CSK_INETSocket::getpeername
  490. *
  491. * DESCRIPTION:
  492. *
  493. * Returns the name of the (remote) peer connected to this socket
  494. *
  495. * PARAMETERS:
  496. *
  497. * void *            -- Pointer to memory for return value
  498. * int *                -- Pointer to memory for return value.  Should be initialized
  499. *                       the amount of space provided for name return
  500. *
  501. * RETURNS:
  502. *
  503. * The function return value indicates error status (0 = no error).  When it is
  504. * -1, a more specific return value is in the global errno.
  505. *
  506. * The name is returned in the given memory, truncated to available space
  507. * if necessary.  The length of the name (or truncated name) is returned
  508. * in the given int * parameter.
  509. *
  510. */
  511.  
  512. int CSK_INETSocket::getpeername(void *name, int *namelen)
  513. {
  514.     if (*namelen < 0)
  515.         return SK_Error(EINVAL);
  516.  
  517.     memcpy(name, &fPeerSocketAddress, *namelen = MIN(*namelen, sizeof(struct sockaddr_in)));
  518.     return 0;
  519. }
  520.  
  521.  
  522. /*************************************************************************** *
  523. * FUNCTION:
  524. *
  525. * CSK_INETSocket::shutdown
  526. *
  527. * DESCRIPTION:
  528. *
  529. * Closes all of part of a full-duplex connection on the given socket.
  530. *
  531. * PARAMETERS:
  532. *
  533. * int            -- How to close connection: If 0, further receives are
  534. *                   disabled; if 1, further sends are disabled; if 2
  535. *                   further sends and receives are disabled.
  536. *
  537. * RETURNS:
  538. *
  539. * The function return value indicates error status (0 = no error).  When it is
  540. * -1, a more specific return value is in the global errno.
  541. *
  542. */
  543.  
  544. int CSK_INETSocket::shutdown(int how)
  545. {
  546.     switch(how) {
  547.     case 0 : 
  548.         fStatus |= SKk_STATUS_NOREAD;
  549.         break;
  550.     case 1 : 
  551.         fStatus |= SKk_STATUS_NOWRITE;
  552.         break;
  553.     case 2 :
  554.         fStatus |= SKk_STATUS_NOREAD | SKk_STATUS_NOWRITE;
  555.         break;
  556.     default :
  557.         return SK_Error(EINVAL);
  558.     }
  559.     
  560.     return 0;
  561. }
  562.  
  563.  
  564. /*************************************************************************** *
  565. * FUNCTION:
  566. *
  567. * CSK_INETSocket::fcntl
  568. *
  569. * DESCRIPTION:
  570. *
  571. * Performs a given flag control operation on this socket.
  572. *
  573. * PARAMETERS:
  574. *
  575. * unsigned int            -- The command to execute, one of:
  576. *
  577. *     F_GETFL        returns the descriptor status flags. The only
  578. *                flag supported is FNDELAY for non-blocking i/o.
  579. *
  580. *     F_SETFL        sets descriptor status flags. The only
  581. *                 flag supported is FNDELAY for non-blocking i/o.
  582. *
  583. * int                    -- The argument for the command
  584. *
  585. * RETURNS:
  586. *
  587. * Upon successful completion, the value  returned  depends  on
  588. * cmd as follows:
  589.  
  590. *     F_GETFL   Value of flags.
  591. *    F_SETFL   0.
  592. *
  593. * On error, a value of -1  is returned and errno is set to indicate 
  594. * the error.
  595. *
  596. *     EBADF        s is not a valid open descriptor.
  597. *
  598. *    EMFILE        cmd is F_DUPFD and socket descriptor table is full.
  599. *
  600. *    EINVAL        cmd is F_DUPFD and arg  is  negative  or
  601. *                 greater   than   the  maximum  allowable
  602. *                number (see SK_getdtablesize).
  603. *
  604. */
  605.  
  606. int CSK_INETSocket::fcntl(unsigned int cmd, int arg)
  607. {
  608.     switch(cmd) {
  609.     
  610.     /* Get socket status.  This is like getsockopt().
  611.        Only supported descriptor status is FNDELAY. */
  612.     case F_GETFL : 
  613.         if (fNonBlocking)
  614.             return FNDELAY;
  615.         else
  616.             return 0;
  617.             
  618.     /* Set socket status.  This is like setsockopt().
  619.        Only supported descriptor status is FNDELAY. */
  620.     case F_SETFL : 
  621.         if (arg & FNDELAY)
  622.             fNonBlocking = true;
  623.         else
  624.             fNonBlocking = false;
  625.         
  626.         return 0;
  627.         
  628.     default:
  629.         return SK_Error(EOPNOTSUPP);
  630.     }
  631. }
  632.  
  633.  
  634. /*************************************************************************** *
  635. * FUNCTION:
  636. *
  637. * CSK_INETSocket::ioctl
  638. *
  639. * DESCRIPTION:
  640. *
  641. * Performs a requested io control action on this socket
  642. *
  643. * PARAMETERS:
  644. *
  645. * unsigned int                -- Requested control action
  646. * void *                    -- Pointer to arguments for given action
  647. *
  648. * RETURNS:
  649. *
  650. * The function return value indicates error status (0 = no error).  When it is
  651. * -1, a more specific return value is in the global errno.
  652. *
  653. */
  654.  
  655. int CSK_INETSocket::ioctl(unsigned int request, void *argp)
  656. {
  657.     struct ifreq *    ifr;
  658.     int                size;
  659.     
  660.     /* Interpret high order word to find amount of data to be copied 
  661.        to/from the user's address space. */
  662.     size =(request &~(IOC_INOUT | IOC_VOID)) >> 16;
  663.     
  664.     /* Zero the buffer on the stack so the user gets back something deterministic */
  665.     if ((request & IOC_OUT) && size)
  666.         bzero((Ptr)argp, size);
  667.  
  668.     ifr =(struct ifreq *)argp;
  669.     switch(request) {
  670.     
  671.     /* Non-blocking I/O */
  672.     case FIONBIO:
  673.         fNonBlocking = (Boolean) *(int *) argp;
  674.         return 0;
  675.         
  676.     /* Number of bytes on input Q */
  677.     case FIONREAD:
  678.         *(unsigned long *) argp    = Available();
  679.         return 0;
  680.         
  681.     default :
  682.         return SK_Error(EOPNOTSUPP);
  683.     }
  684. }
  685.  
  686.  
  687. /**************************************************************************/ 
  688. /**************************************************************************/ 
  689. /* CSK_INETSocketDomain members */
  690.  
  691.  
  692. /*************************************************************************** *
  693. * FUNCTION:
  694. *
  695. * CSK_INETSocketDomain::CSK_INETSocketDomain
  696. *
  697. * DESCRIPTION:
  698. *
  699. * Constructor for this class
  700. *
  701. */
  702.  
  703. CSK_INETSocketDomain::CSK_INETSocketDomain()
  704.     :    CSK_SocketDomain(AF_INET)    
  705. {
  706.     CSK_Configuration    conf;        // SKg_Config isn't yet guaranteed to work    
  707.         
  708.     fDriverState        = 1;
  709.      fResolverState        = 1;
  710.     fDrvrRefNum         = 0;
  711.     fNumExistingSockets    = 0;
  712.             
  713.     /* Allocate storage for pbs */
  714.     fLastPBUsed = 0;
  715.     fThePBArray = NULL;
  716.     
  717.     if (conf.IsDaemon()) {
  718.         if (conf.fTCPDaemon)
  719.             AEInstallEventHandler(
  720.                 'INET', 'TSTR', AEEventHandlerProcPtr(SK_TCPPossession), 0, false);
  721.         else
  722.             AEInstallEventHandler(
  723.                 'INET', 'TSTR', AEEventHandlerProcPtr(SK_UnsupportedAEVT), 0, false);
  724.         
  725.         if (conf.fUDPDaemon)
  726.             AEInstallEventHandler(
  727.                 'INET', 'USTR', AEEventHandlerProcPtr(SK_UDPPossession), 0, false);
  728.         else
  729.             AEInstallEventHandler(
  730.                 'INET', 'USTR', AEEventHandlerProcPtr(SK_UnsupportedAEVT), 0, false);
  731.     }
  732. }
  733.  
  734.  
  735. /*************************************************************************** *
  736. * FUNCTION:
  737. *
  738. * CSK_INETSocketDomain::Driver
  739. *
  740. * DESCRIPTION:
  741. *
  742. * ???
  743. *
  744. * RETURNS:
  745. *
  746. * short        -- The driver reference number (or 0 on error)
  747. *
  748. */
  749.  
  750. short CSK_INETSocketDomain::Driver()
  751. {
  752.     ParamBlockRec         pb; 
  753.  
  754.     if (fDriverState == 1) {
  755.         pb.ioParam.ioCompletion    = 0L; 
  756.         pb.ioParam.ioNamePtr     = "\p.IPP"; 
  757.         pb.ioParam.ioPermssn     = fsCurPerm;
  758.         
  759.         fDriverState             = PBOpenSync(&pb);
  760.         fDrvrRefNum             = pb.ioParam.ioRefNum; 
  761.     }
  762.     
  763.     return fDriverState ? 0 : fDrvrRefNum;
  764. }
  765.  
  766.  
  767. /*************************************************************************** *
  768. * FUNCTION:
  769. *
  770. * CSK_INETSocketDomain::Resolver
  771. *
  772. * DESCRIPTION:
  773. *
  774. * ???
  775. *
  776. * RETURNS:
  777. *
  778. * OSErr        -- The resulting resolver state
  779. *
  780. */
  781.  
  782. OSErr CSK_INETSocketDomain::Resolver()
  783. {
  784.     if (fResolverState == 1)
  785.         fResolverState = OpenResolver(nil);
  786.     
  787.     return fResolverState;
  788. }
  789.  
  790.  
  791. /*************************************************************************** *
  792. * FUNCTION:
  793. *
  794. * CSK_Socket * CSK_INETSocketDomain::socket
  795. *
  796. * DESCRIPTION:
  797. *
  798. * Create a MacTCP socket in this socket domain.
  799. *
  800. * TCP sockets provide sequenced, reliable, two-way connection
  801. * based byte streams.
  802. *
  803. * A TCP socket must be in a connected state before any data may be sent 
  804. * or received on it. A connection to another socket is created with a 
  805. * connect() call or the listen() and accept() calls. Once connected, data may 
  806. * be transferred using read() and write() calls or some variant of the send() 
  807. * and recv() calls. When a session has been completed a close() may  be
  808. * performed.
  809. *
  810. * A UDP socket supports the exchange of datagrams (connectionless, unreliable 
  811. * messages of a fixed maximum length) with correspondents named in send() calls. 
  812. * Datagrams are generally received with recv(), which returns the next
  813. * datagram with its return address.
  814. *
  815. * An fcntl() or ioctl() call can be used to enable non-blocking I/O.
  816. *
  817. * PARAMETERS:
  818. *
  819. * int            -- The type of socket to create:
  820. *
  821. *    SOCK_STREAM        to create a TCP socket
  822. *    SOCK_DGRAM        to create a UDP socket
  823. *
  824. * short            -- unused protocol
  825. *
  826. * RETURNS:
  827. *
  828. * The return value is a descriptor referencing the socket or -1
  829. * if an error occurs, in which case global variable errno is
  830. * set to one of:
  831. *
  832. *    ENOMEM                Failed to allocate memory for the socket
  833. *                         data structures.
  834. *
  835. *    ESOCKTNOSUPPORT     Type wasn't SOCK_STREAM or SOCK_DGRAM.
  836. *
  837. *    EMFILE              The socket descriptor table is full.
  838. *
  839. */
  840.  
  841. CSK_Socket * CSK_INETSocketDomain::socket(int type, short)
  842. {
  843.     CSK_INETSocket * sock = nil;
  844.     
  845.     errno = 0;
  846.  
  847.     if (!Driver())
  848.         return (CSK_Socket *) SK_Error_nil(ENETDOWN);
  849.         
  850.     switch (type)    {
  851.     case SOCK_STREAM:
  852.         sock = new CSK_TCPSocket();
  853.         break;
  854.     case SOCK_DGRAM:
  855.         sock = new CSK_UDPSocket();
  856.         break;
  857.     default:
  858.         SK_Error(ESOCKTNOSUPPORT);
  859.     }    
  860.     
  861.     if (sock && errno)    {
  862.         delete sock;
  863.         return nil;
  864.     }
  865.         
  866.     return sock;
  867. }
  868.  
  869.  
  870. /*************************************************************************** *
  871. * FUNCTION:
  872. *
  873. * CSK_INETSocketDomain::GetPB
  874. *
  875. * DESCRIPTION:
  876. *
  877. * Get a free parameter block from the collection of parameter blocks
  878. * being used by sockets in this domain.
  879. *
  880. * RETURNS:
  881. *
  882. * CSK_AnnotatedPB *            -- The free parameter block object
  883. *
  884. * NOTES:
  885. *
  886. * If all parameter blocks are in use, then this routine will loop until 
  887. * one becomes available (possibly forever, as I am now finding out).
  888. *
  889. */
  890.  
  891. CSK_AnnotatedPB * CSK_INETSocketDomain::GetPB()
  892. {
  893.     CSK_AnnotatedPB    * curPB;
  894.     Boolean once_around = FALSE;
  895.     long final_tick;
  896.     
  897.     /* Error check */
  898.     ASSERT(fThePBArray != NULL);
  899.     
  900.     /* Try to locate a free parameter block */
  901.     do {
  902.         if (++fLastPBUsed == SKk_Num_PBs) {
  903.             // If already went once around without finding anything, then we give
  904.             // up some time to the OS, in the hope that some parameter block will
  905.             // be freed upon a completion
  906.             if (once_around) SystemTask();
  907.             
  908.             once_around = TRUE;
  909.             fLastPBUsed = 0;
  910.             }
  911.         
  912.         curPB = fThePBArray + fLastPBUsed;
  913.     } while (curPB->Busy());
  914.     
  915.     // Return block
  916.     return curPB;
  917. }
  918.  
  919.  
  920. /*************************************************************************** *
  921. * FUNCTION:
  922. *
  923. * CSK_INETSocketDomain::OpenSocket
  924. *
  925. * DESCRIPTION:
  926. *
  927. * ???
  928. *
  929. */
  930.  
  931. void CSK_INETSocketDomain::OpenSocket()
  932. {
  933.     /* Allocate PB array if this is first socket to be opened */
  934.     if (fThePBArray == NULL) {
  935.         fThePBArray = new CSK_AnnotatedPB[SKk_Num_PBs];
  936.         if (fThePBArray == NULL) {
  937.             errno = ENOMEM;
  938.             return;
  939.         }
  940.     }
  941.     
  942.     /* Count this socket */    
  943.     fNumExistingSockets++;
  944. }
  945.  
  946.  
  947. /*************************************************************************** *
  948. * FUNCTION:
  949. *
  950. * CSK_INETSocketDomain::CloseSocket
  951. *
  952. * DESCRIPTION:
  953. *
  954. * ???
  955. *
  956. */
  957.  
  958. void CSK_INETSocketDomain::CloseSocket()
  959. {
  960.     /* Decrement socket counter */
  961.     fNumExistingSockets--;
  962.     
  963.     /* If no sockets left, then deallocate PB array */
  964.     if (fNumExistingSockets == 0) {
  965.         delete [] fThePBArray;
  966.         fThePBArray = NULL;
  967.     }
  968.  }
  969.  
  970.  
  971. /* end of SK_INET.cc */
  972.